var pageobject = null;
// var isselect = false;
var _classPath = "";
var global_page_data = null;
var _pageSize = 20;

/**
 * 数据表格的模板
 **/
var _template_body_html = null;

/**
 * 查询的属性集合
 */
var _global_data_properties = null;

/**
 * ListDto的属性集合
 */
var _global_list_properties = null;

/**
 * 当前主表的属性列表
 */
var _global_class_attributes = null;

/**
 * 配置信息，配置这个模型名称
 */
var _config = {
    className: '',//需要和路径的一致，表示后端的对象
    model: 'view',//当前模式view bind select
    menubox: false,//是否有按钮盒子
    enable_view: false,
    next: null,
    show_type: 'table',//table表格显示chart图表显示
    ui_model: false,//是否被激活为table或者chart模式
    exchange_id: "id",//主键字段，默认为id
    show_key: true,//是否显示默认的id这个字段，也就是表的主键，有时候不想显示
    single_select: true,//选择模式下，是否是单选模式，默认是单选模式
    select_num: 1,//选中多少个后确定
    page_size: [20, 50, 100, 200],//分页的大小
    page_default_size: 20,//默认的分页大小
    batch: false//是否启用批量操作
};

//_config.next.key _config.next.type _config.next.map

var _orderby = "id";

/**
 * 初始化事件数据等
 **/
$(window).ready(function () {

    if(typeof pasteform_custom_config != 'undefined'){
        _config = pasteform_custom_config;
    }

    var _path = _apigetquery("path");
    if (_path != null) {
        _classPath = _path;
        _config.className = _classPath;
    }
    //判断是否是选择模式，就是其他表单的外表
    var _model = _apigetquery("model");
    if (_model != null) {
        _config.model = _model;
        if (_model == 'select' || _model == 'object') {

            var _pf_num = _apigetquery("pf_num");//多选多少个，默认是1个不填也是1个，其他表示多个
            if (_pf_num != null) {
                _config.select_num = parseInt(_pf_num);
            }
            // if (!_pf_num || _pf_num == 1) {
            //     var _top = window.top;
            //     if (_top && _top.FuncHiddenSureButtons) {
            //         _top.FuncHiddenSureButtons();
            //     } else {
            //         console.log('没有在根级找到 FuncHiddenSureButtons');
            //     }
            // } else {
            //     _config.single_select = false;
            // }
            $(".searcharea").fadeOut();
            $(".btnadd").hide();
        }
    }
    var _show_type = _apigetquery('show_type');
    if (_show_type != null) {
        if (_show_type == 'table') {
            _config.ui_model = true;
            _config.show_type = 'table';
        }
        //这样写，防止参数被其他东西占用了
        if (_show_type == 'chart') {
            _config.ui_model = true;
            handlerChangeShowType(true);
        }
    }
    QueryModel();
    //切换排序 查询基于哪个排序基于哪个
    $(".table").on('click', '.ordersell', function () {
        _orderby = $(this).attr('dataval');
        $(".table").find(".ordersell").removeClass('ordered');
        $(this).addClass('ordered');
        _readpagedata(1);//直接基于这个查询第一页
    })
});

/**
 * 显示为chart模式
 */
function handlerChangeShowType(ischart, elc) {
    if (ischart) {
        _config.show_type = 'chart';
        $(".data_echart").show();
        $(".table").hide();
        $(".batcharea").hide();
    } else {
        _config.show_type = 'table';
        $(".data_echart").hide();
        $(".table").show();
        $(".batcharea").show();
    }
    if (elc) {
        if (!$(elc).hasClass('selected')) {
            $(elc).addClass('selected').siblings().removeClass('selected');
        }
        _readpagedata(1);
    } else {
        if (ischart) {
            $('.show_type i').eq(0).addClass('selected').siblings().removeClass('selected');
        } else {
            $('.show_type i').eq(1).addClass('selected').siblings().removeClass('selected');
        }
    }
}

/**
 * 批量模式的全选和非全选
 * @param {*} elc 
 */
function tap_batch_check_change(elc) {
    var _val = $(elc).prop('checked');
    let all = $(".table .trbatch")
    for (let i = 0; i < all.length; i++) {
        $(all[i]).prop("checked", _val)
    }
}

/**
 * 以number的模式返回选中的对象的id
 * @returns 
 */
function FuncReadBitchCheckedNumber() {
    let all = $(".table .trbatch")
    let idarr = []
    for (let i = 0; i < all.length; i++) {
        if ($(all[i]).prop("checked")) {
            idarr.push(Number($(all[i]).closest('tr').attr("dataid")));
        }
    }
    return idarr;
}

/**
 * 以String的模式返回选中的对象的id
 * @returns 
 */
function FuncReadBitchCheckedString() {
    let all = $(".table .trbatch")
    let idarr = []
    for (let i = 0; i < all.length; i++) {
        if ($(all[i]).prop("checked")) {
            idarr.push($(all[i]).closest('tr').attr("dataid"));
        }
    }
    return idarr;
}


/**
 * 显示页面数据到UI
 **/
function _showpagedata(datas) {
    global_page_data = datas;
    datas.forEach(item => {

        if (_select_map) {
            for (var _k of Object.keys(item)) {
                //编辑模式的时候不要转化值
                if (_select_map.has(_k)) {
                    let _property = findPropertyByName(_global_list_properties, _k);
                    if (_property && _property.edit) {
                        continue;
                    } else {
                    }
                    var _val = item[_k];
                    item[_k] = _select_map.get(_k).get(_val);
                }
            }
        }

        var select_map = new Map();

        for (var _key in item) {
            var _val = item[_key];
            if (_val == null) {
                item[_key] = '';
            }
            var _property = funcFindListPropertry(_key);
            if (_property) {
                if (_property.attributes) {
                    if (_val) {
                        for (var _attribute of _property.attributes) {
                            _val = item[_key];
                            switch (_attribute.name) {
                                case "fentoyuan":
                                    {
                                        item[_key] = (Number(_val) / 100).toFixed(2);
                                    }
                                    break;
                                case "datetime":
                                    {
                                        var _format = "yyyy-MM-dd HH:mm:ss";
                                        if (_attribute.args1) {
                                            _format = _attribute.args1;
                                        }
                                        if (_val == 'null' || _val == null) {
                                            item[_key] = '';
                                        }
                                        if (_val) {
                                            if (typeof _val == "number") {
                                                if (_val.length == 10) {
                                                    _val = _val * 1000;
                                                }
                                                var _date = new Date(_val);
                                                item[_key] = _date.Format(_format);
                                            } else {
                                                var _date = new Date(_val);
                                                item[_key] = _date.Format(_format);
                                            }
                                        } else {
                                            item[_key] = "";
                                        }
                                    }
                                    break;
                                    case "select":
                                        {
                                            var select_key =`${_key}_expend_select_values`;
                                            if(!item.hasOwnProperty(select_key)){
                                                select_map.set(select_key,_property.selects);
                                            }
                                        }
                                        break;
                            }
                        }
                    }
                }
            }
        }

        for ( let k of select_map.keys()){
            item[k] = select_map.get(k);
        }

    });

    $("table").find("tbody").html('');
    // console.log(_template_body_html);
    if (_template_body_html != null) {
        var _ahtml = template(_template_body_html, { list: datas, config: _config });
        $(".table").find("tbody").html(_ahtml);
    }
}



/**
 * 搜索区域的高度是否自适应
 */
// var _search_area_auto_height = true;
/**
 * 切换搜索区域的高度
 * @param {*} elc 
 */
function func_auto_searcharea(elc) {
    if (!$(".searcharea").is(":visible")) {
        $(".searcharea").fadeIn();
    } else {

        if ($(".pasteform").hasClass("oneline")) {
            $(".pasteform").removeClass("oneline");
            $(".tap_more .Hui-iconfont-arrow3-bottom").removeClass("Hui-iconfont-arrow3-bottom").addClass("Hui-iconfont-arrow3-top");
        } else {
            $(".pasteform").addClass("oneline");

            $(".tap_more .Hui-iconfont-arrow3-top").removeClass("Hui-iconfont-arrow3-top").addClass("Hui-iconfont-arrow3-bottom");
        }
    }
}

/**
 * 点击新增
 **/
function tap_add_form(elc) {
    //检查是否需要传递参数下去
    var _linkquery = handlerBuildLinkQueryUrl();
    open_window('新增', `${handlerPasteFormPath()}view.html?path=${_classPath}${_linkquery}`, `1200px`);
}

/**
 * 点击编辑
 **/
function tap_view_item(elc) {
    var _id = $(elc).attr('dataid');
    var _linkquery = handlerBuildLinkQueryUrl();
    open_window('编辑', `${handlerPasteFormPath()}view.html?path=${_classPath}&id=${_id}${_linkquery}`, `1200px`);
}

/**
 * 点击详细
 **/
function tap_detail_item(elc) {
    var _id = $(elc).attr('dataid');
    var _linkquery = handlerBuildLinkQueryUrl();
    open_window('查看', `${handlerPasteFormPath()}detail.html?path=${_classPath}&id=${_id}${_linkquery}`, `1200px`);
}

// /**
//  * 读取linkquery的参数以&xxx=yyy&zzz=www的形式
//  * @returns 
//  */
// function handlerBuildLinkQueryUrl(){
//     var _linkquery = "";
//     if (_global_class_attributes) {
//         _global_class_attributes.forEach(_attribute => {
//             if (_attribute.name == "linkquery") {
//                 if (_attribute.args1) {
//                     var _args = _attribute.args1.split(',');
//                     _args.forEach(arg => {
//                         var _argval = _apigetquery(arg);
//                         if (_argval != null) {
//                             _linkquery += `&${arg}=${_argval}`;
//                         }
//                     });
//                 }
//             }
//         });
//     }
//     return _linkquery;
// }

/**
 * 删除这条数据
 * @param {*} elc 
 */
function handler_tap_del(elc) {
    var _id = $(elc).attr('dataid');
    layer.confirm('确定修改状态么？', { btn: ["确定", "取消"] }, function (index) {
        _apipost(`${auto_path()}/${_id}/remove`, true, '', (c, o) => {
            layer.close(index);
            if (c == 200) {
                $(elc).html('已删除');
            }
        });
    }, function () {
    });
}

/**
 * query model=select 的时候作为选择一个对象使用，会使用postMessage向上一个页面推送消息
 * 这里是否需要修改成支持多选模式?
 **/
function tap_select_item(elc) {
    if ($(elc).hasClass('selected')) {
        $(elc).removeClass('selected');
    } else {
        // if (_config.select_num==1) {
        //     $(".table .mselect").removeClass('selected');
        // }//这里如果是单个其实有问题，因为已经确定返回了，应该是多个的时候做一个切换
        $(elc).addClass('selected');
    }
    read_select_values();
}

/**
 * 通知上级点击确定
 */
function sure_select_close_page() {
    // if (find != null && _config.single_select) {
    var _top = window.top;
    if (_top) {
        if (_top.FuncClickSure) {
            _top.FuncClickSure();
        }
    }
    // if (parent) {
    //     if (parent.FuncClickSure) {
    //         parent.FuncClickSure();
    //     }
    // }
    // }
}

/**
 * 读取选定的值
 */
function read_select_values() {
    var items = $(".table").find('.selected');
    if (items && items.length > 0) {
        var ids = new Array();
        for (var k = 0; k < items.length; k++) {
            var _elc = items[k];
            ids.push($(_elc).attr('dataid'));
        }
        var datas = new Array();
        if (global_page_data != null) {
            for (var _id of ids) {
                for (var one of global_page_data) {
                    if (one.id.toString() == _id) {
                        datas.push(one);
                    }
                }
            }
            if (datas.length > 0) {
                if (_config.select_num == 1) {
                    window.SelectObject = datas[0];
                    sure_select_close_page();
                } else {
                    window.SelectObject = datas;
                    if (_config.select_num == datas.length) {
                        sure_select_close_page();
                    }
                }
            }
        }

    } else {
        window.SelectObject = null;
    }
}

/**
 * 获取选中行的数据，是一个[object]格式 基于可编辑的表格实现，需要edit特性配合
 * @returns 
 */
function getSelectedRowsData() {
    const selectedRows = [];
    // 遍历所有选中的复选框所在的行
    $('.table .trbatch:checked').each(function () {
        // const row = $(this).closest('tr');
        const rowData = handlerReadRowData(this)
        selectedRows.push(rowData);
    });
    // console.log(selectedRows);
    return selectedRows;
}

/**
 * 读取当前行数据
 * @param {*} elc 
 * @returns 
 */
function handlerReadRowData(elc) {
    const row = $(elc).closest('tr');
    const rowData = {};
    // 遍历行中的每个 td 元素
    row.find('td[dataname]').each(function () {
        const dataName = $(this).attr('dataname');

        if (dataName) {
            if (dataName.indexOf(".") > 0) {
                return true;//这里我要跳出
            }
        }

        const dataType = $(this).attr('datatype');
        const valType = $(this).attr('valtype');
        let value;
        const input = $(this).find('input:not([type="checkbox"])');
        const select = $(this).find('select');
        const cbox = $(this).find('input[type="checkbox"]');
        if (input.length > 0) {
            value = input.val();
        } else if (select.length > 0) {
            value = select.val();
        } else if (cbox.length > 0) {
            value = $(cbox).is(':checked') ? 'on' : 'off';
        } else {
            value = $(this).text().trim();
        }

        switch (dataType) {
            case "Int32":
            case "Int64":
            case "UInt32":
            case "UInt64":
            case "number":
                {
                    if (value) {
                        value = Number(value);
                    }
                }
                break;
            case "fentoyuan":
                {
                    value = Number(value) * 100;
                }
                break;
            case "Boolean":
            case "bit":
            case "bool":
            case "switch":
                {
                    if (value === 'on' || value === '1' || value === 'checked') {
                        value = true;
                    } else {
                        value = false;
                    }
                }
                break;
            case "Double":
                {
                    value = parseFloat(value);
                }
                break;
            default:
                {
                    switch (valType) {
                        case "number":
                            {
                                if (value) {
                                    value = Number(value);
                                }
                            }
                            break;
                    }
                }
                break;
        }
        //是否还有其他需要解析的
        rowData[dataName] = value;
    });
    return rowData;
}

/**
 * 查询模型信息
 **/
function QueryModel() {
    _apiget(`${auto_path()}/readListModel`, true, (c, o) => {
        if (c == 200) {
            if (o.title) {
                $(".ppbody .st").find(".sn").html(o.title);
                this.document.title = o.title;
            }
            if (o.desc) {
                $(".ppbody .st").find(".idesc").html(o.desc);
            }
            //表头的模板内容
            var _template_head_html = null;

            _global_list_properties = o.properties;

            //如果没有主键id
            if (o.properties) {
                const hasIdProperty = findExistsPropertyByName(_global_list_properties, 'id');
                if (!hasIdProperty) {
                    _config.exchange_id = _global_list_properties[0]?.name;
                    const keyPropertyName = findKeyAttributeProperty(_global_list_properties);
                    if (keyPropertyName) {
                        _config.exchange_id = keyPropertyName;
                    }
                }
                //隐藏主键在表格中
                if (!_config.show_key) {
                    if (_config.exchange_id) {
                        var find = findPropertyByName(_global_list_properties, _config.exchange_id);
                        if (find) {
                            find.hidden = true;
                        }
                    }
                }
            }

            //模型处理，如何显示外表 比如cate.name 
            HandlerModelColumn(o.properties);
            //class模型的属性列表
            if (o.attributes) {
                _global_class_attributes = o.attributes;
                var btns = new Array();
                o.attributes.forEach(_attribute => {
                    switch (_attribute.name) {
                        case "disable":
                            {
                                //是否禁用新增 编辑 删除功能
                                if (_attribute.args1) {
                                    _config.disable_add = true;
                                    $(".btnadd").hide();
                                }
                                if (_attribute.args2) {
                                    _config.disable_edit = true;
                                }
                                if (_attribute.args3) {
                                    _config.disable_del = true;
                                }
                                if (_attribute.args4) {
                                    _config.enable_view = true;
                                }
                            }
                            break;
                        case "template":
                            {
                                //自定义页面表头和表格的模板 之前需要载入模板页面
                                if (_attribute.args1) {
                                    _template_head_html = $(`#${_attribute.args1}`).html();
                                }
                                if (_attribute.args2) {
                                    _template_body_html = $(`#${_attribute.args2}`).html();
                                }
                            }
                            break;
                        case "batch":
                            {
                                if (_config.model == "view") {
                                    //是否启用批量操作
                                    _config.batch = true;
                                    if (!_config.batchs) {
                                        _config.batchs = new Array();
                                    }
                                    let btn = {
                                        name: "",
                                        func: _attribute.args2,
                                        icon: "",
                                        title: ""
                                    };
                                    if (_attribute.args1) {
                                        btn.name = _attribute.args1;
                                    }
                                    if (_attribute.args3) {
                                        btn.icon = _attribute.args3;
                                    }
                                    if (_attribute.args4) {
                                        btn.title = _attribute.args4;
                                    }
                                    _config.batchs.push(btn);
                                }
                            }
                            break;
                        case "button":
                            {
                                if (_attribute.args3 == 'add') {
                                    if (_attribute.args1) {
                                        $(".btnadd").val(_attribute.args1);
                                    }
                                    if (_attribute.args2) {
                                        $(".btnadd").attr('onclick', _attribute.args2);
                                    }
                                } else {
                                    btns.push(_attribute);
                                }
                            }
                            break;
                        case "loadlib":
                            {
                                //载入资源
                                loadLibFile(_attribute.args1, _attribute.args2);
                            }
                            break;
                        case "charty":
                            {
                                let _info = {
                                    type: 'value',
                                    name: "数量",
                                    position: 'left',
                                    offset: 0,
                                    axisLabel: {
                                        formatter: ''
                                    }
                                };
                                if (_attribute.args1) {
                                    _info.name = _attribute.args1;
                                }
                                if (_attribute.args2) {
                                    _info.position = _attribute.args2;
                                }
                                if (_attribute.args3) {
                                    let _off = Number(_attribute.args3);
                                    if (!isNaN(_off)) {
                                        _info.offset = _off;
                                    }
                                }
                                if (_attribute.args4) {
                                    _info.axisLabel.formatter = _attribute.args4
                                }
                                chart_data_yaxis.push(_info);
                            }
                            break;
                        case "ui":
                            {
                                if (_attribute.args2) {
                                    $(".show_type").show();
                                }
                                //防止query的配置被覆盖
                                if (!_config.ui_model) {
                                    if (_attribute.args1 === 'chart') {
                                        handlerChangeShowType(true);
                                    } else {
                                        handlerChangeShowType(true);
                                    }
                                }
                                _config.ui_model = true;
                            }
                            break;
                    }
                });
                if (btns && btns.length > 0) {
                    if (_config.model == "view") {
                        var _ahtml = '<div class="buttons">';
                        btns.forEach(_btn => {
                            _ahtml += `<input type="button" class="btn btnstyle" value="${_btn.args1}" onclick="${_btn.args2}" />`;
                            //这里要改版 有title 等
                        });
                        _ahtml += '</div>';
                        $(".func_btn_area").html(_ahtml);
                    }
                }
            }

            if (_template_head_html == null) {
                _template_head_html = $("#template_header").html();
            }
            var _modelhtml = template(_template_head_html, { list: o.properties, config: _config });

            if (_config.batch) {
                if (_config.batchs.length > 0) {
                    var _batch_template = $("#template_batch").html();
                    var _batch_html = template(_batch_template, _config);
                    $(".batcharea").html(_batch_html);
                }
            }

            //一级模型 转化成 二级模型
            if (_template_body_html == null) {
                var _template_body = $("#template_body").html();
                var _bodyhtml = template(_template_body, { list: o.properties, config: _config });
                _template_body_html = _bodyhtml.replace(/{{/g, '<%').replace(/}}/g, '%>');
                // $("#builded_body_template").html(_template_body_html);
            }
            $(".table").find("thead").html(_modelhtml);
            //处理查询项
            if (o.queryProperties) {
                _global_data_properties = o.queryProperties;
                //载入query的值
                LoadQuery(o.queryProperties);
                //校验格式等
                HandlerQueryItem(o.queryProperties);
            } else {
                _readpagedata(1);
            }
            //读取数据
        }
    });
}

/**
 * 从表格字段中找字段 返回true false
 * @param {*} properties 
 * @param {*} targetName 
 * @returns 
 */
function findExistsPropertyByName(properties, targetName) {
    return properties.some(property => property.name === targetName);
}

/**
 * 查找某一个名称的字段信息
 * @param {*} properties 
 * @param {*} propertyName 
 * @returns 
 */
function findPropertyByName(properties, propertyName) {
    for (const property of properties) {
        if (property.name == propertyName) {
            return property;
        }
    }
    return false;
}

/**
 * 从表格信息中找找看看是否有主键列
 * @param {*} properties 
 * @returns 
 */
function findKeyAttributeProperty(properties) {
    for (const property of properties) {
        if (property.attributes && property.attributes.some(attr => attr.name === "iskey")) {
            return property.name;
        }
    }
    return null;
}



/**
 * 处理列表中表格中的字段的属性信息
 * @param {*} properties 
 */
function HandlerModelColumn(properties) {
    if (properties) {
        properties.forEach(item => {
            // item.className=_classPath;
            item.edit = false;//是否是编辑模式
            item.valueType = "string";
            if (item.value != null) {
                item.valueType = typeof (item.value);
            }
            if (item.attributes) {
                item.attributes.forEach(_attribute => {
                    switch (_attribute.name) {
                        case "html":
                            {
                                item.html = _attribute.args1;
                            }
                            break;
                        case "htmltemplate":
                            {
                                //后续这个删除，用上面的html替代
                                item.html = _attribute.args1;
                            }
                            break;
                        case "ifmenu":
                            {
                                if (_attribute.args1) {
                                    item.ifmenu = {
                                        expression: _attribute.args1,
                                        value: _attribute.args2
                                    };
                                    item.dataType = "ifmenu";
                                    item.hidden = true;
                                    if (_attribute.args3 == 'box') {
                                        item.dataType = "ifmenubox";
                                        if (!_config.menubox) {
                                            _config.menubox = true;
                                        }
                                    }
                                }
                            }
                            break;
                        case "menu":
                            {
                                item.dataType = "menu";
                                item.hidden = true;
                                if (_attribute.args4) {
                                    if (_attribute.args4 == 'box') {
                                        item.dataType = 'menubox';
                                        if (!_config.menubox) {
                                            _config.menubox = true;
                                        }
                                    }
                                }
                            }
                            break;
                        case "tap":
                            {
                                item.dataType = "tap";
                                item.hidden = true;
                                if (_attribute.args4) {
                                    if (_attribute.args4 == 'box') {
                                        item.dataType = 'tapbox';
                                        if (!_config.menubox) {
                                            _config.menubox = true;
                                        }
                                    }
                                }
                            }
                            break;
                        case "outerdisplay":
                            {
                                item.name = _attribute.args2;
                            }
                            break;
                        case "display":
                            {
                                if (_attribute.args1) {
                                    item.name = `${item.name}?.${_attribute.args1}`;
                                } else {
                                    item.name = `${item.name}?.name`;
                                }
                            }
                            break;
                        case "outer":
                            {
                                if (_attribute.args2) {
                                    if (_attribute.args4) {
                                        item.name = `${_attribute.args2}?.${_attribute.args4}`;
                                    } else {
                                        item.name = `${_attribute.args2}?.name`;
                                    }
                                    var _property = funcFindListPropertry(_attribute.args2);
                                    if (_property) {
                                        _property.hidden = true;
                                    }
                                }
                            }
                            break;
                        case "select":
                            {
                                try {
                                    item.dataType = 'select';
                                    item.selects = JSON.parse(_attribute.args1);
                                    var _map = new Map();
                                    item.selects.forEach(ii => {
                                        _map.set(ii.value, ii.name);
                                    });
                                    _select_map.set(item.name, _map);
                                } catch (err) {
                                    console.log(item.name, "属性 select 的值 args1 配置错误", err);
                                }
                            }
                            break;
                        case "hidden":
                            {
                                if (_attribute.args1) {
                                    if (_config.model != _attribute.args1) {
                                        item.hidden = true;
                                    }
                                } else {
                                    item.hidden = true;
                                }
                            }
                            break;
                        case "empty":
                            {
                                item.hidden = true;
                            }
                            break;
                        case "class":
                            {
                                item.class = _attribute.args1;
                            }
                            break;
                        case "switch": {

                            item.switch_func = "undefined";
                            item.switch_confirm = false;
                            if (_attribute.args1) {
                                if (_config.model == _attribute.args1) {
                                    item.dataType = _attribute.name;
                                }
                            } else {
                                item.dataType = _attribute.name;
                            }
                            if (_attribute.args2) {
                                item.switch_confirm = true;
                            }
                            if (_attribute.args3) {
                                item.switch_func = _attribute.args3;
                            }
                            if (_attribute.args4) {
                                if (_attribute.args4 == "local") {
                                    item.switch_local = true;
                                }
                            }
                        }
                            break;
                        case "mark":
                            {
                                var _mark = {
                                    model: _classPath,
                                    value: item.name
                                };
                                if (_attribute.args1) {
                                    _mark.model = _attribute.args1;
                                }
                                if (_attribute.args2) {
                                    _mark.value = _attribute.args2;
                                }
                                item.mark = _mark;
                            }
                            break;
                        case "edit":
                            {
                                if (_attribute.args1) {
                                    if (_attribute.args1 == _config.model) {
                                        item.edit = true;
                                    }
                                }
                                if (_attribute.args2) {
                                    if (_attribute.args2 == _config.model) {
                                        item.edit = true;
                                    }
                                }
                                if (_attribute.args3) {
                                    if (_attribute.args3 == _config.model) {
                                        item.edit = true;
                                    }
                                }
                                if (_attribute.args4) {
                                    if (_attribute.args4 == _config.model) {
                                        item.edit = true;
                                    }
                                }
                            }
                            break;
                        case "prefix":
                            {
                                // item[_key] = `${_attribute.args1}${_val}`;
                                item.prefix = _attribute.args1;
                            }
                            break;
                        case "unit":
                            {
                                // item[_key] = `${_val}${_attribute.args1}`;
                                item.unit = _attribute.args1;
                            }
                            break;
                        case "image":
                            {
                                item.dataType = _attribute.name;
                            }
                            break;
                        case "minbtn":
                            {
                                item.minbtn = {
                                    name: _attribute.args1,
                                    func: "func_min_btn_click(this,'{{:=item.id}}','" + item.name + "')",
                                    class: ""
                                };
                                if (_attribute.args2) {
                                    item.minbtn.func = _attribute.args2;
                                }
                                if (_attribute.args3) {
                                    item.minbtn.class = _attribute.args3;
                                }
                            }
                            break;
                        default:
                            {
                                // item.dataType = _attribute.name;
                            }
                            break;
                    }
                });
            }
        });
    }
}

/**
 * 
 */
var _select_map = new Map();

/**
 * 从服务端获取查询项，检查格式，并把查询项写入到searcharea对应的UI中
 **/
function HandlerQueryItem(listproperties) {
    var _temp = new Array();
    listproperties.forEach(item => {
        item.dataFrom = item.dataType;
        if (item.attributes) {
            item.attributes.forEach(_attribute => {
                switch (_attribute.name) {
                    case "select":
                        {
                            try {
                                item.dataType = 'select';
                                item.selects = JSON.parse(_attribute.args1);
                                for (let sitem of item.selects) {
                                    sitem.selected = false;//改版成值来命中
                                }
                                var _map = new Map();
                                item.selects.forEach(ii => {
                                    _map.set(ii.value, ii.name);
                                });
                                _select_map.set(item.name, _map);
                            } catch (err) {
                                console.log(item.name, "属性 select 的值 args1 配置错误", err);
                            }
                        }
                        break;
                    case "datalist":
                        {
                            item.dataType = 'datalist';
                            item.datalistid = item.name;
                            if (_attribute.args1) {
                                try {
                                    item.selects = JSON.parse(_attribute.args1);
                                    for (let sitem of item.selects) {
                                        sitem.selected = false;//改版成值来命中
                                    }
                                } catch (err) {
                                    console.log(item.name, "属性 datalist 的值 args1 配置错误", err);
                                }
                            } else {
                                item.datalistid = _attribute.args2;
                                if (_attribute.args3) {
                                    try {
                                        eval(_attribute.args3);
                                    } catch (err) {
                                    }
                                }
                            }
                        }
                        break;
                    case "hidden":
                        {
                            item.hidden = true;
                            if (_attribute.args1) {
                                if (_config.model == _attribute.args1) {
                                    item.hidden = false;
                                }
                            }
                        }
                        break;
                    case "mark":
                        {
                            var _mark = {
                                model: _classPath,
                                value: item.name
                            };
                            if (_attribute.args1) {
                                _mark.model = _attribute.args1;
                            }
                            if (_attribute.args2) {
                                _mark.value = _attribute.args2;
                            }
                            item.mark = _mark;
                        }
                        break;
                    case "daterange":
                        {
                            item.dataType = "daterange";
                            if (_attribute.args2) {
                                var _target = funcFindExpendPropertry(_attribute.args2, item.name);
                                if (_target) {
                                    _target.hidden = true;
                                }
                            }
                            //2个时间合并到一个去 注意要和js的保持一致 比如yyyy-MM-dd  至  yyyy-MM-dd
                            var _start = "";
                            var _end = "";
                            if (_attribute.args1 == item.name) {
                                _start = item.value;
                            } else {
                                if (_attribute.args1) {
                                    var _arg1_obj = funcFindExpendPropertry(_attribute.args2, item.name);
                                    if (_arg1_obj) {
                                        if (_arg1_obj.value) {
                                            _start = _arg1_obj.value;//默认为yyyy-MM-dd HH:mm:ss格式
                                            //时间可能是时间戳格式
                                            if (_attribute.args4) {
                                                switch (_attribute.args4) {
                                                    case "times":
                                                        {
                                                            _start = new Date(_start * 1000).Format('yyyy-MM-dd HH:mm:ss');
                                                        }
                                                        break;
                                                    case "timems":
                                                        {
                                                            _start = new Date(_start * 1000).Format('yyyy-MM-dd HH:mm:ss');
                                                        }
                                                        break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            if (_start && _attribute.args2) {
                                var _arg2_obj = funcFindExpendPropertry(_attribute.args2, item.name);
                                if (_arg2_obj) {
                                    if (_arg2_obj.value) {
                                        _end = _arg2_obj.value;
                                        if (_attribute.args4) {
                                            switch (_attribute.args4) {
                                                case "times":
                                                    {
                                                        _end = new Date(_end * 1000).Format('yyyy-MM-dd HH:mm:ss');
                                                    }
                                                    break;
                                                case "timems":
                                                    {
                                                        _end = new Date(_end * 1000).Format('yyyy-MM-dd HH:mm:ss');
                                                    }
                                                    break;
                                            }
                                        }
                                        var _fulldate = `${new Date(_start).Format('yyyy-MM-dd')}  至  ${new Date(_end).Format('yyyy-MM-dd')}`;
                                        item.value = _fulldate;
                                    }
                                }
                            }

                            // item.dataType = 'daterange';
                            // if (_attribute.args2) {
                            //     var _target = funcFindPropertry(_attribute.args2);
                            //     if (_target) {
                            //         _target.hidden = true;
                            //     }
                            // }
                            // //2个时间合并到一个去 注意要和js的保持一致 比如yyyy-MM-dd  至  yyyy-MM-dd
                            // var _start = "";
                            // var _end = "";
                            // if (_attribute.args1 == item.name) {
                            //     _start = item.value;
                            // } else {
                            //     if (_attribute.args1) {
                            //         var _args1obj = funcFindPropertry(_attribute.args2);
                            //         if (_args1obj) {
                            //             if (_args1obj.value) {
                            //                 _start = _args1obj.value;
                            //             }
                            //         }
                            //     }
                            // }
                            // if (_start && _attribute.args2) {
                            //     var _args1obj = funcFindPropertry(_attribute.args2);
                            //     if (_args1obj) {
                            //         _args1obj.hidden = true;
                            //         if (_args1obj.value) {
                            //             _end = _args1obj.value;
                            //             var _fulldate = `${new Date(_start).Format('yyyy-MM-dd')}  至  ${new Date(_end).Format('yyyy-MM-dd')}`;
                            //             item.value = _fulldate;
                            //             // console.log(_fulldate);
                            //         }
                            //     }
                            // }
                        }
                        break;
                    case "outer":
                        {
                            item.dataType = 'outer';
                        }
                        break;
                    case "selects":
                    case "lselect":
                        {
                            try {
                                item.dataType = _attribute.name;
                                item.selects = JSON.parse(_attribute.args1);
                                for (let sitem of item.selects) {
                                    sitem.selected = false;//改版成值来命中
                                }
                                if (item.value || item.value == 0) {

                                    var _typeof = typeof (item.value);
                                    switch (_typeof) {
                                        case "string":
                                            {
                                                var _splitchar = ',';
                                                if (_attribute.args2) {
                                                    _splitchar = _attribute.args2;
                                                }
                                                var strs = item.value.split(_splitchar);
                                                item.selects.forEach(ii => {
                                                    if (strs.indexOf(ii.value) >= 0) {
                                                        ii.selected = true;
                                                    }
                                                });
                                            }
                                            break;
                                        case "number":
                                            {
                                                var _vals = item.value;
                                                item.selects.forEach(ii => {
                                                    if (_vals == (ii.value)) {
                                                        ii.selected = true;
                                                    }
                                                });
                                            }
                                            break;
                                        case "object":
                                            {
                                                if (Array.isArray(item.value)) {
                                                    item.selects.forEach(ii => {
                                                        if (item.value.indexOf(ii.value) >= 0) {
                                                            ii.selected = true;
                                                        }
                                                    });
                                                } else {
                                                    var _vals = item.value.toString();
                                                    item.selects.forEach(ii => {
                                                        if (_vals.indexOf(ii.value.toString()) >= 0) {
                                                            ii.selected = true;
                                                        }
                                                    });
                                                }
                                            }
                                            break;
                                    }

                                }
                            } catch (err) {
                                console.log(item.name, "属性 select 的值 args1 配置错误", err);
                            }
                        }
                        break;
                    case "next_key":
                        {
                            _config.next.key = item.name;
                            if (item.dataType == "Int32" || item.dataType == "Int64") {
                                _config.next.type = "number";
                            } else {
                                _config.next.type = "string";
                            }
                            if (_attribute.args1) {
                                _config.next.key = _attribute.args1;
                            }
                            item.hidden = true;
                        }
                        break;
                }
            });
        }

        if (item.name == 'orderby') {
            if (item.value) {
                _orderby = item.value;
            }
            item.hidden = true;
        }

        if (item.dataFrom == "Guid") {
            if (item.value == "00000000-0000-0000-0000-000000000000") {
                item.value = "";
                if (item.display == "00000000-0000-0000-0000-000000000000") {
                    item.display = "";
                }
            }
        }

        if (item.name == "next_key") {
            _config.next.key = item.name;
            if (item.dataType == "Int32" || item.dataType == "Int64") {
                _config.next.type = "number";
            } else {
                _config.next.type = "string";
            }
            item.hidden = true;
        }

        //过滤掉默认存在的 如果后端要修改size？
        if (item.name != "page" && item.name != "size") {
            if (item.dataType == "DateTime") {
                if (!item.format) {
                    item.format = "yyyy-MM-dd HH:mm:ss";
                }
                item.required = true;
            }
            if (item.dataType == "String") {
                if (!item.maxlength) {
                    item.maxlength = 64;
                }
            }
            //外表选择?
            _temp.push(item);//hidden的也需要显示在UI，所以后端需要给默认值
        } else {
            if (item.name == "size") {
                if (item.value) {
                    _pageSize = parseInt(item.value);
                }
            }
            item.hidden = true;
        }
        //初始化daterange
    });
    if (_temp.length > 0) {
        var _template_query = $("#template_search").html();
        var _ahtml = template(_template_query, { list: _temp, config: _config });
        $(".searchbox").append(_ahtml);

        setTimeout(function () {
            if (chart_table) {
                chart_table.resize();
            }
            InitUiData();
            _readpagedata(1);
            if ($(".searchbox").height() > 60) {
                $(".tap_more").fadeIn();
            }
        }, 300);
    } else {
        _readpagedata(1);
    }
    // console.log(listproperties);
}

/**
 * 数据载入后，初始化一些绑定等操作
 */
function InitUiData() {
    if (_global_data_properties) {
        _global_data_properties.forEach(item => {
            if (item.dataType == 'daterange') {
                HandlerInitDateRange(item.name, item.value);
            }
            // if (item.attributes) {
            //     item.attributes.forEach(_attribute => {
            //         if (_attribute.name == 'query') {
            //             if (_attribute.args1) {
            //                 var _query_value = _apigetquery(_attribute.args1);
            //                 if (_query_value != null && _query_value != undefined) {
            //                     // _info[item.name] = _query_value;
            //                     $(`[name=${item.name}]`).val(_query_value);
            //                     if (_attribute.args2) {
            //                         $(`[name=${item.name}]`).parents('.sitem').hide();
            //                     }
            //                 }
            //             }
            //         }
            //     });
            // }
        });

        if ($(".ulitems").length > 0) {
            /**
     * selects lselect 下面逻辑有问题！
     */
            $(".ulitems").on('click', 'li', function () {
                if ($(this).hasClass('selected')) {
                    $(this).removeClass('selected');
                } else {
                    $(this).addClass('selected');
                }
                var _name = $(this).parents(".ulitems").attr('name');
                if (_name) {
                    var _pro = funcFindPropertry(_name);
                    if (_pro) {
                        var _maxnum = 0;
                        var _attribute = funcFindAttribute(_pro.attributes, "selects");
                        if (_attribute) {
                            if (_attribute.args4) {
                                _maxnum = Number(_attribute.args4);
                            }
                        } else {
                            _attribute = funcFindAttribute(_pro.attributes, "lselect");
                            if (_attribute) {
                                if (_attribute.args4) {
                                    _maxnum = Number(_attribute.args4);
                                }
                            }
                        }
                        if (_maxnum > 0) {
                            if (_maxnum == 1) {
                                $(this).siblings().removeClass('selected');
                            }
                            var _selnum = $(this).parents(".ulitems").find(".selected").length;
                            if (_selnum > _maxnum) {
                                // $(this).siblings().removeClass('selected');
                                $(this).removeClass('selected');
                                if (_maxnum > 1) {
                                    layer.msg(`限定最多选择${_maxnum}项`);
                                }
                            }
                            if (_maxnum == 1 && _selnum > 0) {
                                _readpagedata(1);
                            }
                        }
                    }
                }
            });
        }
    }
}





/**
 * 提交搜索前数据校验
 * @param {*} _info 
 */
function handlerInputValue(_info) {
    if (_global_data_properties) {
        _global_data_properties.forEach(item => {
            switch (item.dataType) {
                case "daterange":
                    {
                        if (item.attributes) {
                            for (let _attribute of item.attributes) {
                                if (_attribute.name == 'daterange') {
                                    var _value = _info[item.name];//获取当前选中的值
                                    if (_value) {
                                        var splits = _value.split('  ');
                                        if (splits.length == 3) {
                                            let _start = `${splits[0]} 00:00:00`;
                                            let _end = `${splits[2]} 00:00:00`;
                                            if (_attribute.args1) {
                                                // _info[_attribute.args1] = _start;
                                                setValueToSameLevel(item.name, _info, _attribute.args1, _start);
                                            }
                                            if (_attribute.args2) {
                                                // _info[_attribute.args2] = _end;
                                                setValueToSameLevel(item.name, _info, _attribute.args2, _end);
                                            }

                                            if (_attribute.args4) {
                                                switch (_attribute.args4) {
                                                    case "times":
                                                        {
                                                            let _times = new Date(_start).getTime() / 1000;
                                                            let _timee = new Date(_end).getTime() / 1000;
                                                            // _info[_attribute.args1] = _times;
                                                            // _info[_attribute.args2] = _timee;
                                                            setValueToSameLevel(item.name, _info, _attribute.args1, _times);
                                                            setValueToSameLevel(item.name, _info, _attribute.args2, _timee);
                                                        }
                                                        break;
                                                    case "timems":
                                                        {
                                                            let _times = new Date(_start).getTime();
                                                            let _timee = new Date(_end).getTime();
                                                            // _info[_attribute.args1] = _times;
                                                            // _info[_attribute.args2] = _timee;
                                                            setValueToSameLevel(item.name, _info, _attribute.args1, _times);
                                                            setValueToSameLevel(item.name, _info, _attribute.args2, _timee);
                                                        }
                                                        break;
                                                }
                                            }
                                        }
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    break;
                case "Guid":
                case "DateTime":
                    {
                        if (!item.required) {
                            if (_info[item.name] == "null" || _info[item.name] == '') {
                                delete _info[item.name];
                            }
                        }
                    }
                    break;
                case "selects":
                case "lselect":
                    {
                        //基于结果进行值拼接！
                        var _elcs = $(`[name=${item.name}]`).find('.selected');
                        if (_elcs && _elcs.length > 0) {
                            var _array = new Array();
                            for (var k = 0; k < _elcs.length; k++) {
                                _array.push($(_elcs[k]).attr('value'));
                            }
                            if (item.dataFrom.indexOf("[]") >= 0) {
                                if (item.dataFrom == "Int32[]" || item.dataFrom == "Int64[]") {
                                    var _newarray = new Array();
                                    _array.forEach(_ary => {
                                        _newarray.push(Number(_ary));
                                    });
                                    _info[item.name] = _newarray;
                                } else {
                                    _info[item.name] = _array;
                                }
                            } else {
                                //string

                                if (item.dataFrom == 'Int32' || item.dataFrom == 'Int64') {
                                    _info[item.name] = Number(_array[0]);
                                } else {
                                    var _splitchar = ',';
                                    if (item.attributes) {
                                        for (var _attribute of item.attributes) {
                                            if (_attribute.name == item.dataType) {
                                                if (_attribute.args2) {
                                                    _splitchar = _attribute.args2;
                                                }
                                                break;
                                            }
                                        }
                                    }
                                    _info[item.name] = _array.join(_splitchar);
                                }
                            }
                        }
                    }
                    break;
            }
            if (typeof (item.value) == 'number') {
                if (!_info.hasOwnProperty(item.name)) {
                    _info[item.name] = 0;
                }
            }

            if (item.nullable) {
                var _value = null;
                if (_info.hasOwnProperty(item.name)) {
                    _value = _info[item.name];
                }
                //null的问题应该是API处理
                if (!_value) {
                    delete _info[item.name];
                }
                switch (item.dataFrom) {
                    case "DateTime":
                    case "Guid":
                        {
                            if (_info[item.name] == "null" || _info[item.name] == '') {
                                delete _info[item.name];
                            }
                        }
                        break;
                }
            }
            //int类型的0可能被忽略，这样后台会命中比如默认值-1的情况

        });
    }
}


/**
 * 查找这个属性
 **/
function funcFindListPropertry(_name) {
    if (_global_list_properties) {
        for (var one of _global_list_properties) {
            if (one.name == _name) {
                return one;
            }
        }
    }
    return null;
}



/**
 * 打开选择一个外表的值
 **/
function funcLinkOuterOpenSelect(_title, _className, num, callback) {
    var _url = _className;
    if (_url.indexOf('/') == -1) {
        _url = `${handlerPasteFormPath()}index.html?model=select&path=${_className}`;
    }
    _url = handlerBuildDynamicUrl(_url);
    open_select(_title, _url + '&pf_num=' + num, "", "", callback);

}

/**
 * 
 * @param {*} elc 
 */
function open_menu_box(elc) {
    $(".menubox").hide();
    var _width = $(elc).parent().width();
    var _menubox = $(elc).parent().find(".menubox");
    if (_menubox) {
        $(_menubox).css('right', (_width + 20));
        $(_menubox).fadeIn();
    }
}

/**
 * 删除输入框的值
 * @param {*} elc 
 */
function handlerSearchClean(elc) {
    var _parent = $(elc).parents('.sitem');
    if (_parent) {
        _parent.find('input,textarea').val('');
    }
}

/**
 * 
 * @param {*} elc 
 */
function handlerSearchCleanOuterInput(elc) {
    var _parent = $(elc).parents('.outer');
    if (_parent) {
        _parent.find('input,textarea').val('');
    }
}

/**
 * 删除输入框的值
 * @param {*} elc 
 */
function handlerCleanOuterInput(elc) {
    var _parent = $(elc).parents('.outer');
    if (_parent) {
        _parent.find('input,textarea').val('');
    }
}



/**
 * 输入框回车发送
 * @param {*} event 
 */
function handler_keyup(event) {
    if (event.key == 'Enter') {
        _readpagedata(1);
    }
}

/**
 * 下拉后执行读取数据
 * @param {*} e 
 */
function handler_select_change(e) {
    _readpagedata(1);
}

/**
 * 表格中的switch的开关触发
 * @param {*} elc 
 */
function handlerSwitchChange(elc, confirm, func_name) {
    // dataid dataname
    if (func_name && func_name != "undefined") {
        const func_direct = window[func_name];
        if (typeof func_direct == 'function') {
            func_direct(elc);
        }
    } else {
        var _value = $(elc).prop('checked');//true/false
        if (confirm == 'true') {
            layer.confirm('当前操作会修改数据，是否继续？', { btn: ["确定", "取消"] }, function (index) {
                layer.close(index);
                handlerSwitchUpload(elc);
            }, function () {
                $(elc).prop('checked', !_value);
                return;
            });
        } else {
            handlerSwitchUpload(elc);
        }
    }
}

/**
 * 处理点击switch的提交
 * @param {*} elc 
 */
function handlerSwitchUpload(elc) {
    var _dataid = $(elc).attr('dataid');// 1或者guid等主键
    var _dataname = $(elc).attr('dataname');//isEnable
    var _value = $(elc).prop('checked');//true/false
    var _info = {
        id: _dataid,
        name: _dataname,
        state: _value,
        search: location.search
    };
    //由后端基于这个参数自己决定如何处理
    _apipost(`${auto_path()}/updateState`, true, JSON.stringify(_info), (c, o) => {
        if (c != 200) {
            $(elc).prop('checked', !_value);
        }
    });
}

/**
 * location.search转化成一个object
 * @param {*} queryString 
 * @returns 
 */
function parseQueryString(queryString) {
    // 去掉开头的 '?'
    if (queryString.startsWith('?')) {
        queryString = queryString.slice(1);
    }

    // 分割成键值对
    const pairs = queryString.split('&');

    // 创建一个空对象来存储结果
    const result = {};

    // 遍历每个键值对
    pairs.forEach(pair => {
        const [key, value] = pair.split('=');
        // 解码键和值
        const decodedKey = decodeURIComponent(key);
        const decodedValue = decodeURIComponent(value || ''); // 处理没有值的情况
        // 如果键已经存在，转换为数组
        if (result.hasOwnProperty(decodedKey)) {
            if (Array.isArray(result[decodedKey])) {
                result[decodedKey].push(decodedValue);
            } else {
                result[decodedKey] = [result[decodedKey], decodedValue];
            }
        } else {
            result[decodedKey] = decodedValue;
        }
    });

    return result;
}

// // 使用示例
// const queryObject = parseQueryString(location.search);
// console.log(queryObject);

/**
 * 处理获取到的数据
 **/
function _readpagedata(page) {
    if (page == 1) {
        $("#pagenumarea").empty();
    }
    var _info = $("#formsearch").parseForm();
    //这里要做输入结果的校验，转化等
    handlerInputValue(_info);
    _info.page = page;
    _info.size = _pageSize;
    _info.orderby = _orderby;
    if (_config.next != null) {
        if (_config.next.key) {
            if (_config.next.map) {
                var _read = _config.next.map.get(page);
                if (_read) {
                    _info[_config.next.key] = _read;
                }
            }
        }
    }

    if(!_info.hasOwnProperty('show_type')){
        _info.show_type = _config.show_type;
    }

    if (location.search) {
        var _querys = parseQueryString(location.search);
        for (var _key in _querys) {
            _info[_key] = _querys[_key];
        }
    }

    // console.log(_info);
    _apiquery(`${auto_path()}/page`, true, _info, function (code, obj) {
        var _show_empty = false;
        if (code == 200) {
            if (obj.items.length > 0) {
                var datas = obj.items;
                //补充主key的数据
                if (_config.exchange_id != 'id') {
                    datas.forEach(element => {
                        if (element.hasOwnProperty(_config.exchange_id)) {
                            element["id"] = element[_config.exchange_id];
                        }
                    });
                }
                //判断类型
                if (_config.show_type == 'table') {
                    _showpagedata(datas);
                } else {
                    if (echarts_loaded) {
                        showPageChart(datas);
                    } else {
                        loadEchartsLib().then(() => {
                            showPageChart(datas);
                        }).catch(() => {
                            console.error('加载图表组件失败！');
                        });
                    }
                }
                if (pageobject == null) {
                    pageobject = $('#pagenumarea').pagination({
                        current: page,  // 默认为1
                        pageSize: _pageSize,  // 默认为10
                        sizeArray: _config.page_size,//可以切换每页多少
                        total: obj.totalCount,  // 默认0
                        callback: function (pageIndex, pagination, pageSize) {
                            _pageSize = pageSize;
                            _readpagedata(pageIndex);
                        }
                    })
                } else {
                    if (page == 1) {
                        pageobject.setTotal(obj.totalCount);
                    }
                }
            } else {
                _show_empty = true;
            }

            if (_config.next != null) {
                if (_config.next.key) {
                    if (obj.hasOwnProperty(_config.next.key)) {
                        if (!_config.next.map) {
                            var _map = new Map();
                            _map.set((page + 1), obj[_config.next.key]);
                            _config.next.map = _map;
                        } else {
                            var _map = _config.next.map;
                            _map.set((page + 1), obj[_config.next.key]);
                        }
                    }
                }
            }

        } else {
            if (code == 204) {
                //没有查询到数据
                _show_empty = true;
            }
        }
        if (_show_empty) {
            global_page_data = null;
            $("#pagenumarea").empty();
            var _html = `<div class="nodata">
                <div class="nobody">
                    <span>没有数据</span>
                    <i class="Hui-iconfont Hui-iconfont-search"></i>
                </div>
            </div>`;
            $(".table").find("tbody").html(_html);
        }
    });
}

var echarts_loaded = false;

/**
 * 载入echarts组件 按需载入
 */
async function loadEchartsLib() {
    if (!echarts_loaded) {
        await new Promise((resolve, reject) => {
            var _script = document.createElement("script");
            _script.src = "../lib/echarts.min.js";
            _script.type = "text/javascript";
            _script.onload = function () {
                resolve();
            }
            _script.onerror = function () {
                reject();
            }
            document.head.appendChild(_script);
        });
        echarts_loaded = true;
    } else {
        return new Promise((resolve) => {
            resolve();
        });
    }
}

/**
 * 图表的数据轴信息 比如注册量 PV PU等标题
 */
var chart_data_heads = new Array();
/**
 * 数据Y轴 比如数量 金额 单量
 */
var chart_data_yaxis = new Array();
/**
 * 数据轴 比如成交量 退款量 成交金额 退款金额当数据
 */
var chart_data_series = new Array();
/**
 * 数据X轴是哪个 一般是时间
 */
var chart_data_xaxis = null;
/**
 * 图表对象
 */
var chart_table = null;
/**
 * 图表形式显示数据
 * @param {*} datas 
 */
function showPageChart(datas) {

    if (!chart_data_yaxis || chart_data_yaxis.length == 0) {
        //获得 单量 金额 等左右数据柱
        if (_global_class_attributes) {
            for (let _ymodel of _global_class_attributes) {
                if (_ymodel.name == 'charty') {
                    let _info = {
                        type: 'value',
                        name: "数量",
                        position: 'left',
                        offset: 0,
                        axisLabel: {
                            formatter: ''
                        }
                    };
                    if (_ymodel.args1) {
                        _info.name = _ymodel.args1;
                    }
                    if (_ymodel.args2) {
                        _info.position = _ymodel.args2;
                    }
                    if (_ymodel.args3) {
                        let _off = Number(_ymodel.args3);
                        if (!isNaN(_off)) {
                            _info.offset = _off;
                        }
                    }
                    if (_ymodel.args4) {
                        _info.axisLabel.formatter = _ymodel.args4
                    }
                    chart_data_yaxis.push(_info);
                }
            }
        } else {
            console.error('图表chart模式，需要在ListDto的Class中标注特性charty作为左右数据柱信息!');
        }
    }

    if (!chart_data_heads || chart_data_heads.length == 0) {
        chart_data_heads = new Array();
        for (let _property of _global_list_properties) {
            if (_property.attributes) {
                var _attribute = funcFindAttribute(_property.attributes, "chartseries");
                if (_attribute) {
                    chart_data_heads.push(_property.title);
                }
                if (chart_data_xaxis == null) {
                    var _attrcharty = funcFindAttribute(_property.attributes, "chartx");
                    if (_attrcharty) {
                        chart_data_xaxis = _property.name;
                    }
                }
            }
        }
    }

    chart_data_series = new Array();
    for (let _property of _global_list_properties) {
        if (_property.attributes) {
            var _attribute = funcFindAttribute(_property.attributes, "chartseries");
            if (_attribute) {
                // chart_data_heads.push(_property.title);
                let _info = {
                    extend_name: _property.name,
                    extend_type: 'line',
                    extend_index: 0,
                    extend_title: _property.title,
                    extend_datas: new Array()
                };
                if (_attribute.args1) {
                    _info.extend_type = _attribute.args1;
                }
                if (_attribute.args2) {
                    _info.extend_index = Number(_attribute.args2);
                    if (isNaN(_info.extend_index)) {
                        _info.extend_index = 0;
                    }
                }
                if (_attribute.args3) {
                    _info.extend_title = _attribute.args3;
                }
                chart_data_series.push(_info);
            }
        }
    }


    var option = {
        title: {
            text: ''
        },
        tooltip: {
            trigger: 'axis'
        },
        toolbox: {
            show: true
        },
        grid: {
            left: '10%',
            right: '10%',
            top: '10%',
            bottom: '10%'
        },
        legend: {
            data: chart_data_heads,
            top: '20'
        },
        xAxis: {
            data: []
        },
        yAxis: chart_data_yaxis,
        series: []
    };

    let xdatas = new Array();

    for (let item of datas) {
        //看看是否需要格式转化
        if (item.hasOwnProperty(chart_data_xaxis)) {
            xdatas.push(item[chart_data_xaxis]);
        }
        for (let dy of chart_data_series) {
            dy.extend_datas.push(item[dy.extend_name]);
        }
    }

    option.xAxis.data = xdatas;

    chart_data_series.forEach(yy => {
        let seri = {
            smooth: true,
            name: '',
            type: 'line',
            data: new Array(),
            yAxisIndex: 0,
            showSymbol: true
        };
        seri.data = yy.extend_datas;
        seri.name = yy.extend_title;
        seri.type = yy.extend_type;
        seri.yAxisIndex = yy.extend_index;
        option.series.push(seri);
    });
    // console.log(option);
    if (!chart_table) {
        //初始化echarts实例
        chart_table = echarts.init(document.getElementById('data_echart'));
        //使用制定的配置项和数据显示图表
        chart_table.setOption(option);
        // 监听窗口大小变化事件
        window.addEventListener('resize', function () {
            chart_table.resize();//多次执行这里会不会重复?
        });
    } else {
        //使用制定的配置项和数据显示图表
        chart_table.setOption(option);
    }
    // //初始化echarts实例
    // chart_table = echarts.init(document.getElementById('data_echart'));
    // //使用制定的配置项和数据显示图表
    // chart_table.setOption(option);
    // // 监听窗口大小变化事件
    // window.addEventListener('resize', function () {
    //     chart_table.resize();//多次执行这里会不会重复?
    // });
}

